home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / internet-tools / amipop118 / source / pop_main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-26  |  9.5 KB  |  539 lines
  1. /* AmiPOP By Scott Ellis */
  2.  
  3. #include "pop.h"
  4.  
  5. UBYTE VersionID[]="$VER: AmiPOP "VERSION " "__AMIGADATE__ ;
  6.  
  7. /* Variables in pop.h */
  8.  
  9. char *pophost=NULL;
  10. char *username=NULL;
  11. char *password=NULL;
  12. char *passfake=NULL;
  13. char *mailbox=NULL;
  14. char *cxname=NULL;
  15. char *cxdesc=NULL;
  16. char *hotkey=NULL;
  17. char *title=NULL;
  18. char *temp=NULL;
  19. char *buf=NULL;
  20. UBYTE *PubScreenName=NULL;
  21.  
  22. const char bum[]="Ok";
  23.  
  24. BOOL delmail=FALSE;
  25. BOOL checkper=FALSE;
  26. BOOL appfile=TRUE;
  27. BOOL winop=TRUE;
  28. BOOL notify=FALSE;
  29. BOOL immediate=FALSE;
  30. BOOL quiet=FALSE;
  31. BOOL once=FALSE;
  32. BOOL titlebar=FALSE;
  33.  
  34. int timecheck=10;
  35. int port=110;
  36. int winx=0;
  37. int winy=0;
  38.  
  39. struct MsgPort *amipop_mp=NULL;
  40. struct MsgPort *timer_mp=NULL;
  41. struct timerequest *timerio=NULL;
  42. CxObj *broker=NULL;
  43. struct Library *TimerBase=NULL;
  44. struct IntuitionBase *IntuitionBase=NULL;
  45. struct Library *GadToolsBase=NULL;
  46.  
  47.  
  48. struct NewBroker newbroker = {
  49.     NB_VERSION,   /* nb_Version - Version of the NewBroker structure */
  50.     "Not Active", /* nb_Name */
  51.     VersionID + 6,/* nb_Title - Title of commodity that appears in CXExchange */
  52.     "Not Active", /* nb_Descr */
  53.     NBU_NOTIFY | NBU_UNIQUE ,            /* nb_Unique - Tells CX not to launch another commodity with same name */
  54.     COF_SHOW_HIDE,            /* nb_Flags - Tells CX if this commodity has a window */
  55.     0,            /* nb_Pri - This commodity's priority */
  56.     0,            /* nb_Port - MsgPort CX talks to */
  57.     0             /* nb_ReservedChannel - reserved for later use */
  58. };
  59.  
  60. struct EasyStruct ereq =
  61.     {
  62.     sizeof(struct EasyStruct),
  63.     0,
  64.     "AmiPOP Notice",
  65.     "%s",
  66.     "%s",
  67.     };
  68.  
  69. #ifndef OS30
  70. UWORD __chip waitPointer[] =
  71.     {
  72.     0x0000, 0x0000,     /* reserved, must be NULL */
  73.  
  74.     0x0400, 0x07C0,
  75.     0x0000, 0x07C0,
  76.     0x0100, 0x0380,
  77.     0x0000, 0x07E0,
  78.     0x07C0, 0x1FF8,
  79.     0x1FF0, 0x3FEC,
  80.     0x3FF8, 0x7FDE,
  81.     0x3FF8, 0x7FBE,
  82.     0x7FFC, 0xFF7F,
  83.     0x7EFC, 0xFFFF,
  84.     0x7FFC, 0xFFFF,
  85.     0x3FF8, 0x7FFE,
  86.     0x3FF8, 0x7FFE,
  87.     0x1FF0, 0x3FFC,
  88.     0x07C0, 0x1FF8,
  89.     0x0000, 0x07E0,
  90.  
  91.     0x0000, 0x0000,     /* reserved, must be NULL */
  92.     };
  93. #endif
  94.  
  95. enum args
  96.     {
  97.     USERNAME,
  98.     PASSWORD,
  99.     POPHOST,
  100.     MAILBOX,
  101.     CHECKPER,
  102.     TIME,
  103.     DELETE,
  104.     APPEND,
  105.     NOWINDOW,
  106.     PORT,
  107.     NOTIFY,
  108.     CX_POPKEY,
  109.     IMMEDIATE,
  110.     QUIET,
  111.     PUBSCREEN,
  112.     ONCE,
  113.     WINX,
  114.     WINY,
  115.     TITLEBAR
  116.     };
  117.  
  118. /* Configure SAS Specific routines */
  119.  
  120. void __regargs __chkabort(void) {}
  121. long __stack = 20000;
  122.  
  123. /* End SAS */
  124.  
  125. /* Now define the structure that we will get when we start up the program */
  126. typedef struct popstruct {
  127.     char pophost[BIGSTRING];
  128.     char username[SMALLSTRING];
  129.     char password[SMALLSTRING];
  130.     char passfake[SMALLSTRING];
  131.     char mailbox[BIGSTRING];
  132.     char cxname[BIGSTRING];
  133.     char cxdesc[3*BIGSTRING];
  134.     char hotkey[BIGSTRING];
  135.     char title[256];
  136.     char temp[BUFSIZE];
  137.     char buf[BUFSIZE];
  138.     char PubScreenName[SMALLSTRING];
  139. } PopStruct;
  140.  
  141. ULONG            sigmask=NULL;
  142. ULONG            cxsigflag=NULL;
  143. ULONG            timesigflag=NULL;
  144.  
  145. struct Library *IconBase;
  146. struct RDArgs   *RDA;
  147.  
  148. int main(int argc, char **argv)
  149. {
  150.     int foo=0;
  151.     ULONG    mysig;
  152.  
  153. #ifdef OS30
  154.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",39L);
  155. #else
  156.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37L);
  157. #endif
  158.     GadToolsBase = OpenLibrary("gadtools.library",37L);
  159.  
  160.     if (GadToolsBase && IntuitionBase)
  161.     {
  162.         if (makevars())
  163.         {
  164.             freevars();
  165.             return(20);
  166.         }
  167.  
  168.         if ( parse(argc) )
  169.         {
  170.             if ( setuptime() )
  171.             {
  172.                 timesigflag = 1L << timer_mp->mp_SigBit;
  173.                 timereq();
  174.                 foo=1;
  175.  
  176.                 if ( setupcx() )
  177.                 {
  178.                     if (winop)
  179.                     {
  180.                         openup();
  181.                     }
  182.                 }
  183.                 else
  184.                 {
  185.                     foo=0;
  186.                 }
  187.             }
  188.         }
  189.         else
  190.         {
  191.             foo=0;
  192.         }
  193.  
  194.         if (once && foo)
  195.         {
  196.             MYGAD_BUTTONClicked();
  197.             foo=0;
  198.         }
  199.  
  200.         if (immediate && foo) MYGAD_BUTTONClicked(); /* Check mail immediately */
  201.  
  202.         while (foo)
  203.         {
  204.             if (winop)
  205.             {
  206.                 sigmask= 1 << Project0Wnd->UserPort->mp_SigBit ;
  207.             }
  208.             else
  209.             {
  210.                 sigmask= NULL;
  211.             }
  212.  
  213.             mysig=Wait ( sigmask | cxsigflag | timesigflag | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F);
  214.  
  215.             if ( mysig & cxsigflag )
  216.             {
  217.                 foo=docx();
  218.             }
  219.                    if ( mysig & sigmask )
  220.             {
  221.                 foo=HandleProject0IDCMP();
  222.             }
  223.  
  224.             if ( mysig & timesigflag )
  225.             {
  226.                 if (checkper)
  227.                 {
  228.                     MYGAD_BUTTONClicked();
  229.                 }
  230.                 timereq();
  231.             }
  232.  
  233.             if ( mysig & SIGBREAKF_CTRL_C )
  234.             {
  235.                 foo=0;
  236.             }
  237.  
  238.             if (    mysig & SIGBREAKF_CTRL_F )
  239.             {
  240.                 MYGAD_BUTTONClicked();
  241.             }
  242.         }
  243.  
  244.         closedown();
  245.  
  246.         closetime();
  247.  
  248.         closecx();
  249.  
  250.         freevars();
  251.     }
  252.  
  253.     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  254.     if (GadToolsBase) CloseLibrary(GadToolsBase);
  255.  
  256.     return(0);
  257. }
  258.  
  259. void openup(void)
  260. {
  261.     SetupScreen();
  262.     OpenProject0Window();
  263.  
  264.     winop=TRUE;
  265. }
  266.  
  267. void closedown(void)
  268. {
  269.     CloseProject0Window();
  270.     CloseDownScreen();
  271.  
  272.     winop=FALSE;
  273. }
  274.  
  275.  
  276. BOOL parse( int argc )
  277. {
  278.     LONG    *ArgumentArray;        /* array for storing arguments retrieved by */
  279.     const char none[]="None Given";
  280.  
  281.     if (!(ArgumentArray = ParseParameters(argc, "Username/K,Password/K,POPHost/K,MailBox/K,CheckPer/S,"
  282.                                 "Time/K/N,Delete/S,Append/S,NoWindow/S,Port/K/N,Notify/S,"
  283.                                 "Cx_Popkey/K,Immediate/S,Quiet/S,PubScreen/K,Once/S,"
  284.                                 "WinX/K/N,WinY/K/N,TitleBar/S")))
  285.     {
  286.         FreeParameters(ArgumentArray);
  287.         return(FALSE);
  288.     }
  289.     else
  290.     {
  291.         if (ArgumentArray[USERNAME])
  292.         {
  293.             strcpy(username,(char *)ArgumentArray[USERNAME]);
  294.         }
  295.         else
  296.         {
  297.             strcpy(username,none);
  298.         }
  299.  
  300.         if (ArgumentArray[PASSWORD])
  301.         {
  302.             strcpy(password,(char *)ArgumentArray[PASSWORD]);
  303.         }
  304.         else
  305.         {
  306.             strcpy(password,"");
  307.         }
  308.  
  309.         if (ArgumentArray[POPHOST])
  310.         {
  311.             strcpy(pophost,(char *)ArgumentArray[POPHOST]);
  312.         }
  313.         else
  314.         {
  315.             strcpy(pophost,none);
  316.         }
  317.  
  318.         if (ArgumentArray[MAILBOX])
  319.         {
  320.             strcpy(mailbox,(char *)ArgumentArray[MAILBOX]);
  321.         }
  322.         else
  323.         {
  324.             strcpy(mailbox,none);
  325.         }
  326.  
  327.         checkper=(BOOL)ArgumentArray[CHECKPER];
  328.  
  329.         if (ArgumentArray[TIME])
  330.         {
  331.             timecheck=*(int *)ArgumentArray[TIME];
  332.         }
  333.  
  334.         delmail=(BOOL)ArgumentArray[DELETE];
  335.         appfile=(BOOL)ArgumentArray[APPEND];
  336.         winop=!( (BOOL)ArgumentArray[NOWINDOW] );
  337.  
  338.         if (ArgumentArray[PORT])
  339.         {
  340.             port = *(int *)ArgumentArray[PORT];
  341.         }
  342.  
  343.         notify=(BOOL)ArgumentArray[NOTIFY];
  344.  
  345.         if (ArgumentArray[CX_POPKEY])
  346.         {
  347.             strcpy(hotkey,(char *)ArgumentArray[CX_POPKEY]);
  348.         }
  349.  
  350.         if (ArgumentArray[IMMEDIATE])
  351.         {
  352.             immediate=TRUE;
  353.         }
  354.  
  355.         if (ArgumentArray[QUIET])
  356.         {
  357.             quiet=TRUE;
  358.         }
  359.  
  360.         if (ArgumentArray[PUBSCREEN])
  361.         {
  362.             strcpy(PubScreenName,(UBYTE *)ArgumentArray[PUBSCREEN]);
  363.         }
  364.  
  365.         if (ArgumentArray[ONCE])
  366.         {
  367.             once=TRUE;
  368.         }
  369.  
  370.         if (ArgumentArray[WINX])
  371.         {
  372.             winx = *(int *)ArgumentArray[WINX];
  373.         }
  374.  
  375.         if (ArgumentArray[WINY])
  376.         {
  377.             winy = *(int *)ArgumentArray[WINY];
  378.         }
  379.  
  380.         if (ArgumentArray[TITLEBAR])
  381.         {
  382.             titlebar=TRUE;
  383.         }
  384.  
  385.         FreeParameters(ArgumentArray);
  386.  
  387.         return(TRUE);
  388.     }
  389.  
  390. }
  391.  
  392.  
  393. LONG *ParseParameters(int argc, char *OriginalTemplate)
  394. {
  395.     LONG    *ArgumentArray;        /* array for storing arguments retrieved by */
  396.  
  397.     char    **ToolArrayIndex,    /* workbench tooltypes array */
  398.             *ToolStringIndex,    /* index into string of concatenated workbench tooltypes */
  399.             *Template;            /* readargs template - varies slightly for WB or CLI */
  400.  
  401.     struct DiskObject    *DiskObject;    /* pointer to diskobject associated with program icon */
  402.     WORD    ArgCount = 1;        /* number of arguments in template */
  403.  
  404.     RDA = AllocDosObjectTags(DOS_RDARGS, TAG_DONE);
  405.     RDA->RDA_ExtHelp = NULL;
  406.  
  407.     Template = AllocVec(strlen(OriginalTemplate)+16,MEMF_CLEAR);
  408.  
  409.     for (    ToolStringIndex = OriginalTemplate;
  410.             ToolStringIndex = strchr(ToolStringIndex,',');
  411.              ToolStringIndex++, ArgCount++);
  412.  
  413.     ArgumentArray = AllocVec((ArgCount+1)*4,MEMF_CLEAR);
  414.  
  415.     if (argc==0)
  416.     {
  417.         if (IconBase = OpenLibrary("icon.library", 36L) )
  418.         {
  419.             CurrentDir(_WBenchMsg->sm_ArgList->wa_Lock);
  420.  
  421.             if (DiskObject = GetDiskObject(_WBenchMsg->sm_ArgList->wa_Name))
  422.             {
  423.                 for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  424.                         *ToolArrayIndex;
  425.                         ToolArrayIndex++)
  426.                 {
  427.                     RDA->RDA_Source.CS_Length += (strlen(*ToolArrayIndex)+1);
  428.                 }
  429.  
  430.                 if (RDA->RDA_Source.CS_Length)
  431.                 {
  432.                     RDA->RDA_Source.CS_Buffer = AllocVec(RDA->RDA_Source.CS_Length+1,MEMF_CLEAR);
  433.                     ToolStringIndex = RDA->RDA_Source.CS_Buffer;
  434.  
  435.                     for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  436.                             *ToolArrayIndex;
  437.                             ToolArrayIndex++)
  438.                     {
  439.                         ToolStringIndex = stpcpy(stpcpy(ToolStringIndex,*ToolArrayIndex)," ");
  440.                     }
  441.  
  442.                     *(ToolStringIndex-1) = '\n';
  443.                     FreeDiskObject(DiskObject);
  444.                 }
  445.             }
  446.         }
  447.  
  448.         stpcpy(stpcpy(Template,OriginalTemplate),",ThrowAway/M");
  449.  
  450.     }
  451.     else
  452.     {
  453.         strcpy(Template,OriginalTemplate);
  454.     }
  455.  
  456.     RDA = ReadArgs(Template,ArgumentArray,RDA);
  457.  
  458.     FreeVec(Template);
  459.  
  460.     if (RDA)
  461.     {
  462.         return(ArgumentArray);
  463.     }
  464.     else
  465.     {
  466.         return(NULL);
  467.     }
  468. }
  469.  
  470. void FreeParameters(LONG *ArgumentArray)
  471. {
  472.     if (RDA)
  473.     {
  474.         if ((RDA->RDA_Source.CS_Length) && (RDA->RDA_Source.CS_Buffer))
  475.         {
  476.             FreeVec(RDA->RDA_Source.CS_Buffer);
  477.         }
  478.  
  479.         FreeArgs(RDA);
  480.         FreeDosObject(DOS_RDARGS,RDA);
  481.     }
  482.     else
  483.     {
  484.         PrintFault(IoErr(), NULL);
  485.     }
  486.  
  487.     if (ArgumentArray)
  488.     {
  489.         FreeVec(ArgumentArray);
  490.     }
  491. }
  492.  
  493.  
  494. int doreq( const char *mes, const char *but)
  495. {
  496.     LONG answer;
  497.  
  498.     if ( !quiet )
  499.     {
  500.         answer= EasyRequest(NULL, &ereq, NULL, mes, but);
  501.  
  502.         if (Project0Wnd)
  503.         {
  504.             SetWindowTitles(Project0Wnd,Project0Wdt, (UBYTE *) ~0);
  505.         }
  506.  
  507.         return(answer);
  508.     }
  509. }
  510.  
  511. BOOL makevars(void)
  512. {
  513.     PopStruct *blockptr;
  514.  
  515.     if ( blockptr=AllocVec(sizeof(PopStruct),MEMF_CLEAR) )
  516.     {
  517.         pophost=blockptr->pophost;
  518.         username=blockptr->username;
  519.         password=blockptr->password;
  520.         passfake=blockptr->passfake;
  521.         mailbox=blockptr->mailbox;
  522.         cxname=blockptr->cxname;
  523.         cxdesc=blockptr->cxdesc;
  524.         hotkey=blockptr->hotkey;
  525.         title=blockptr->title;
  526.         temp=blockptr->temp;
  527.         buf=blockptr->buf;
  528.         PubScreenName=blockptr->PubScreenName;
  529.         return(FALSE);
  530.     }
  531.  
  532.     return(TRUE);
  533. }
  534.  
  535. void freevars(void)
  536. {
  537.     if (pophost) FreeVec(pophost);
  538. }
  539.